package com.xc.pattern.single;

/**
 * @author xingchen
 * @description 单例设计模式 - 懒汉实现方式
 * @create 2022-08-16 21:49
 */
public class SingletonLazy {


    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     */
    private SingletonLazy() {

    }


    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法调用成功");
    }

    /**
     * 第一种方式
     * 对外暴露一个方法获取类的对象
     * 线程不安全，多线程下存在安全问题
     *
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }

        return instance;
    }

    /**
     * 第二种方式
     * 通过加锁 synchronized 保证单例
     * 采用synchronized 对方法加锁有很大的性能开销
     *
     * @return
     */
    public static synchronized SingletonLazy getInstanceSafe() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

    /**
     * 第三种方式
     * 也存在线程安全问题
     *
     * @return
     */
    public static SingletonLazy getInstanceSafe2() {
        if (instance == null) {
            //A、B线程 多线程下  存在非空判断的问题 A创建完对象后释放锁，B线程也紧跟着进来创建了对象
            synchronized (SingletonLazy.class) {
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

    /**
     * 第四种方式
     * DCL 双重检查锁定  (Double-Checked-Locking),在多线程情况下保持高性能
     * 这是否安全，instance = new SingletonLazy(); 并不是原子性操作
     * 1、分配空间给对象
     * 2、在空间内创建对象
     * 3、将对象复制给引用instance
     * 假如线程是 1-》3-》2顺序，在执行第3步的时候会把值写回主内存，其他线程就会读取到instance最新的值，但是这个是不完全的对象
     * （指令重拍）
     *
     * @return
     */

    public static SingletonLazy getInstanceSafe3() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }


    /**
     * 第五种方式
     * volatile 是java提供的关键词，它具有可⻅性和有序性，可以禁止指令重排
     * 指令重排序是JVM对语句执⾏的优化，只要语句间没有依赖，那JVM就有权对语句进⾏优化
     *
     * @return
     */
    private static volatile SingletonLazy instanceVol;

    public static SingletonLazy getInstanceSafe4() {
        //第一重检查
        if (instanceVol == null) {
            //A、B 等多线程  锁定
            synchronized (SingletonLazy.class) {
                //第二重检查
                if (instanceVol == null) {
                    instanceVol = new SingletonLazy();
                }
            }
        }
        return instanceVol;
    }

}
